1. Field of the Invention
The present invention relates generally to object-oriented programming, and more particularly, to a method and system for creating and configuring a component-based, object-oriented program using a text-based descriptive attribute grammar.
2. Identification of Copyright
A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
3. Description of the Background Art
Over the last two decades, object-oriented frameworks have become increasingly important in the design and development of software applications. Designing an application with a framework of objects, or "components," promises numerous benefits, including the ability to reuse those components in a variety of different applications. Object-oriented frameworks thus reduce development times and ensure more reliable code.
The promised benefits of object-oriented frameworks, however, have not always been easy to realize in practice. In particular, specifying how different components from a framework are initialized and how they interact with each other often requires trained programmers and expertise in arcane programming languages. Creating and configuring component-based applications is often a complex, time-consuming process. The ability to quickly and easily configure component based applications without requiring extensive programming expertise has thus become a much sought after goal of framework builders and end-users alike.
Concurrently, but independently from the above, the Standard Generalized Markup Language (SGML) was conceived for "marking up" text-based structured documents in a standardized and system-independent manner using only a descriptive attribute grammar and associated document type definition (DTD). Recently, one dialect is of SGML--"HTML"--has become the dominant grammar used on the World Wide Web. Because HTML has a simple, declarative syntax, it is relatively easy for non-programmers to learn. Moreover, HTML's standardized, declarative syntax makes it extremely easy to build tools and editors that manipulate HTML files in user-friendly ways. As a result of the Web's explosive growth and HTML's relative simplicity, HTML and HTML-oriented tools have become extremely popular and widely used by a variety of technical and non-technical end-users.
In many situations, it would be highly desirable to be able to create and configure sophisticated component-based applications using only a text-based, SGML-compliant application description language such as HTML. A text-based description language for component-based applications offers many advantages. For example, the text-based data file may be edited by a simple text editor and requires no special or proprietary editing tools. Similarly, SGML compliance allows such data files to be edited, parsed, verified and analyzed by a wide variety of standardized tools. A great number of third-party applications and tools have already been built for managing and manipulating HTML-based content on the Internet. Moreover, a descriptive syntax is much easier for non-programmers to learn and use than traditional programming language constructs. By basing an application description language on a standardized descriptive syntax already familiar to a wide variety of end-users, the language would be more quickly assimilated by developers and non-programmers than a proprietary syntax or traditional programming languages.
As component-based application design has increased in importance, many attempts have been made to create application frameworks that simplify the design process. However, none of those frameworks are based on the standardized, text-based descriptive grammar described above, nor realize the advantages resulting therefrom. Examples of these attempts include the following:
(1) integrated development environments for object-oriented languages such as Smalltalk.TM., Objective-C, C++ and Java.TM., which offer developers the ability to build and design complex component-based applications in a given programming language; PA1 (2) component-based frameworks and protocols, such as ActiveX/COM.RTM., JavaBeans.TM. and CORBA, which provide standard rules and interfaces for regulating the interaction of heterogeneous components; PA1 (3) multi-purpose "scripting" languages, such as JavaScript.TM., Visual Basic.RTM., Scheme, PERL, and the like, designed to facilitate the coordination and use of existing, external components; PA1 (4) "visual" authoring tools, such as Sun Microsystem's.RTM. Javastudio.TM. and Symantec's.RTM. Visual Cafe which provide "easy-to-use" graphic user-interfaces for creating and configuring component-based applications in a given object-oriented language; and PA1 (5) script-oriented "authoring tools" such as Apple's.RTM. Hypertalk or Macromedia's.RTM. Director.RTM., which provide user-friendly environments for developing multimedia applications using the tools' built-in functionality and single-purpose, proprietary scripting languages.
Although the above systems offer solutions to a variety of development problems, none, however, allow applications to be effectively created and configured using a text-based application description language based on an SGML-compliant syntax. For example, integrated development environments, component-based frameworks, and most visual authoring tools output object-code binary files which are interpreted and executed by the user's operating system or the given language's "virtual machine." Java "applet" builders, for instance, typically generate Java source or object code directly. Such binary code files are not text-based and thus are neither editable nor accessible to text-oriented tools.
Although interpreted scripting languages such as JavaScript, Hypertalk, and Lingo can be edited in a generic text editor, their syntax is procedural rather than declarative. As a result, the semantic content of these script files can only be productively inspected and analyzed by the specific tools and editors dedicated to that particular language. In short, while there are a wealth of powerful component-oriented application frameworks and authoring tools, none of them are based on a standardized, text-based descriptive grammar or realize the advantages which accompany being based on such a grammar.
Analogously, numerous efforts have been made to extend the ability of SGML and HTML to specify more sophisticated formatting instructions. For example, HTML's pending versions include numerous processing and formatting instructions to assist developers in creating "multimedia" documents that provide basic interactivity through external "scripting" languages that control "black box" components such as Java applets and/or ActiveX components. Originally, HTML was intended as a purely descriptive syntax that would be transparently portable and easy to understand by both technical and non-technical publishers. The newly evolving hybrid-HTML attempts to expand its functionality by adding simple scripting capabilities to HTML's original descriptive tags and of creating an "open" environment for the integration of third-party components.
However, the hybrid-HTML format has a number of limitations and disadvantages. For example, since hybrid-HTML mixes procedural scripts with descriptive markup tags, a scripting code is required in order to control the behavior of objects within the HTML document. Thus, HTML publishers must understand and master procedural programming in order to take advantage of HTML's newest features. Moreover, critical semantic information is now embedded in procedural code. These procedural "scripts" cannot be inspected or parsed by generic, SGML tools and often contain instructions proprietary to a particular browser vendor.
Another disadvantage is that, in the hybrid-HTML format, each component "plug-in" is a separate and independent "black box" with its own, idiosyncratic interface to the browser's scripting language. Even components developed in a common language, such as Java-based applets, are controlled through the particular interface exposed by a specific applet. Thus, it is difficult, particularly for non-programmers, to integrate a variety of components into a single component-based application.
Yet another problem is that, although HTML tags can be used to declare attributes associated with standard browser components and user-interface controls, there is little or no coordination between the structure of the markup tags and the underlying data structures employed by the browser application itself. For example, HTML elements do not "inherit" properties from "superclass" elements. Thus, hybrid-HTML does not provide a sufficiently sophisticated architecture to integrate large-scale component-based applications.
Finally, hybrid-HTML is limited by the rigidity of HTML itself. By design, HTML only allows for a fixed set of element and attribute tags. There is no provision for developers to add new functionality through application-specific element tags or attributes. Nor is there any ability to map new element tags to new components or to extend the functionality of the browser application through code-based subclassing. Fundamentally, HTML was designed and is still used as a document markup language that is "processed" by an autonomous application: the browser. The intent and design of HTML was to provide a standardized format for marking up "multimedia" documents. All sophisticated application processing is delegated to external resources, i.e. scripting languages, embedded "applets", server-side applications, and the like. Consequently, HTML-based browsers were not designed to actually create and configure a component-based application through descriptive tags alone.
The Extensible Markup Language (XML) proposal recently submitted to the World Wide Web Consortium (W3C) attempts to loosen some of these restrictions on HTML in order to create a simple, declarative syntax that can be used for a wider variety of data-oriented files. In particular, XML allows developers to add new element tags and attributes as long as these comply with the XML specification. Current initiatives using the proposed XML standard include Microsoft's "Channel Definition Format", Netscape's "Meta-Content Framework", and Peter Murray-Rust's "Chemical Definition Language."
While attempts have been made to integrate XML with such object-oriented applications and languages such as Java, C++, and Tc1, existing systems offer only a rudimentary parameterization of the resulting components and require external scripting or programming code in order to provide more sophisticated interactivity. XML has the flexibility and simplicity to provide the syntactic framework for configuring component-based applications. No existing method or system, however, has effectively tapped XML's potential.
What is needed, then, is a method and system for creating and fully configuring component-based applications using a text-based XML-compliant grammar. Moreover, what is needed is a system and method for modeling the component structure of an application through a declarative syntax, such that the component model instantiated by the application mirrors the element tag structure of the original application description file. Additionally, what is needed is a means for specifying the user-oriented interactive behavior of an application in purely descriptive form without resorting to procedural or functional language. Moreover, what is needed is a means for expressing how a component should respond to events within the limits of the XML syntax. Similarly, what is needed is a system and method that permits custom event messages to be created and processed at runtime by components without any special underlying support code on the part of the component. In addition, what is needed is means for specifying complex inter-component behaviors within the limits of a descriptive grammar and without resorting to procedural or functional language. Moreover, what is needed is a means for dynamically specifying the component types used by the application such that new component classes and functionality may be added to the system at runtime. Additionally, what is needed is method for referencing any given component in the application through a scoped, text-based name mechanism. What is also needed a system and method for dynamically controlling and interacting with any of the components of the given application through a single, top-level method call that takes only character arrays as its parameters.